home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / ccdl151s.zip / INCLUDE / CC.P < prev    next >
Text File  |  1997-06-13  |  13KB  |  383 lines
  1.  
  2. /* Protogen Version 1.00 Saturday May 31, 1997  17:24:41 */
  3.  
  4.                               /* Analyze.c */
  5.  
  6. int equalnode(ENODE *node1, ENODE *node2);
  7. CSE *searchnode(ENODE *node);
  8. ENODE *copynode(ENODE *node);
  9. CSE *enternode(ENODE *node,int duse,int size);
  10. CSE *voidauto(ENODE *node);
  11. void voidall(void);
  12. void scanexpr(ENODE *node, int duse,int size);
  13. void scan(SNODE *block);
  14. void exchange(CSE **c1);
  15. int     desire(CSE *csp);
  16. int     bsort(CSE **list);
  17. void repexpr(ENODE *node, int size);
  18. void repcse(SNODE *block);
  19. void allocstack(void);
  20. void opt1(SNODE *block);
  21.  
  22.                                /* Cmain.c */
  23.  
  24. void bool_setup(char select, char *string); /* PROTOTYPE */
  25. void err_setup(char select, char *string); /* PROTOTYPE */
  26. void incl_setup(char select, char *string); /* PROTOTYPE */
  27. void def_setup(char select, char *string); /* PROTOTYPE */
  28. void codegen_setup(char select, char *string); /* PROTOTYPE */
  29. void optimize_setup(char select, char *string); /* PROTOTYPE */
  30. void warning_setup(char select, char *string); /* PROTOTYPE */
  31. void parsefile(char select, char *string); /* PROTOTYPE */
  32. void bool_setup(char select, char *string);
  33. void codegen_setup(char select, char *string);
  34. void optimize_setup(char select, char *string);
  35. void err_setup(char select, char *string);
  36. void incl_setup(char select, char * string);
  37. void def_setup(char select, char *string);
  38. void setglbdefs(void);
  39. void InsertAnyFile(FILE *inf, FILE *outf, char *filename, char *path, int drive);
  40. void dumperrs(FILE *file); /* PROTOTYPE */
  41. void setfile(char *buf,char *orgbuf,char *ext);
  42. int parse_arbitrary(char *string);
  43. void parsefile(char select, char *string);
  44. void addinclude(void);
  45. int parseenv(char *name);
  46. void dumperrs(FILE *file);
  47. void summary(void);
  48. void ctrlchandler(int aa);
  49. int main(int argc,char *argv[]);
  50.  
  51.                                /* Decl.c */
  52.  
  53. void declini(void);
  54. int     imax(int i,int j);
  55. char    *litlate(char *s);
  56. TYP     *maketype(int bt,int siz);
  57. TYP *cponetype(TYP *t);
  58. TYP *copytype(TYP *itp, int flags);
  59. void     decl(TABLE *table);
  60. void decl1(void);
  61. void decl2(void);
  62. void decl3(void);
  63. int bitsize(int type);
  64. int oksize(void);
  65. int     basedeclare(TABLE *table,int al,long ilc,int ztype, int flags);
  66. int     declare(TABLE *table,int al,int ztype, int flags);
  67. int     declare2(TABLE *table,int al,int ztype, int flags, long val);
  68. int     declbegin(int st);
  69. void declenum(TABLE *table);
  70. void enumbody(TABLE *table);
  71. void declstruct(TABLE *table, int ztype, int flags);
  72. void structbody(TYP *tp,char  *name,int ztype);
  73. void check_used(void);
  74. void compile(void);
  75. void dodecl(int defclass);
  76. void doargdecl(int defclass, char *names[], int *nparms, TABLE *table, int isinline);
  77.  
  78.                                /* Error.c */
  79.  
  80. void initerr(void);
  81. void warning_setup(char select, char *string);
  82. void diag(char *s);
  83. int printerr(char *buf, ERRORS *err);
  84. void     lferror(void);
  85. void basicskim(int *skimlist);
  86. BALANCE *newbalance(BALANCE *bal);
  87. void setbalance(BALANCE **bal);
  88. void expskim(int *skimlist);
  89. void basicerror(int n, void *data);
  90. void Error(char *string);
  91. void generror(int n, int data, int *skimlist);
  92. void gensymerror(int n, char *data);
  93. void genfuncerror(int n, char*func, char *data);
  94. void genfunc2error(int n, char*func, char *func2);
  95. void genclasserror(int n, char *struc, char *elem);
  96. void genmismatcherror(TYP *tp1, TYP *tp2);
  97. void expecttoken(int n, int *skimlist);
  98. void generrorexp(int n, int data, int *skimlist);
  99. void gensymerrorexp(int n, char *data);
  100. void expecttokenexp(int n, int *skimlist);
  101.  
  102. /* Protogen Version 1.00 Saturday May 31, 1997  17:24:41 */
  103.  
  104.                                /* Expr.c */
  105.  
  106. void exprini(void);
  107. ENODE    *makenode(enum e_node nt, char *v1, char *v2);
  108. TYP *deref(ENODE **node, TYP *tp);
  109. ENODE *dummyvar(int size, TYP *type);
  110. int isintconst(int type);
  111. TYP     *nameref(ENODE **node);
  112. void promote_type(TYP *typ, ENODE **node);
  113. TYP *gatherparms( ENODE **node);
  114. void checkparmconst(TYP *tp, TYP *tpi);
  115. void parmlist(ENODE **node, TYP *tpi, TYP *tp);
  116. int floatrecurse(ENODE *node);
  117. void floatcheck(ENODE *node);
  118. int     castbegin(int st);
  119. int tostring(void);
  120. TYP     *primary(ENODE **node);
  121. int            castvalue(ENODE *node);
  122. int     lvalue(ENODE *node);
  123. TYP     *unary(ENODE **node);
  124. TYP *maxsize(TYP *tp1, TYP *tp2);
  125. TYP     *forcefit(ENODE **node1,TYP *tp1,ENODE **node2,TYP *tp2, int max, int allowpointers);
  126. int     isscalar(TYP *tp);
  127. void checknp(TYP *tp1,TYP*tp2,ENODE *ep1, ENODE *ep2);
  128. TYP     *multops(ENODE **node);
  129. TYP     *addops(ENODE **node);
  130. TYP     *shiftop(ENODE **node);
  131. TYP     *relation(ENODE **node);
  132. TYP     *equalops(ENODE **node);
  133. TYP     *binop(ENODE **node,TYP *(*xfunc)(),int nt,int sy);
  134. TYP     *bitand(ENODE **node);
  135. TYP     *bitxor(ENODE **node);
  136. TYP     *bitor(ENODE **node);
  137. TYP     *andop(ENODE **node);
  138. TYP     *orop(ENODE **node);
  139. TYP     *conditional(ENODE **node);
  140. TYP            *autoasnop(ENODE **node, SYM *sp);
  141. void asncombine(ENODE **node);
  142. TYP     *asnop(ENODE **node,TYP *tptr);
  143. TYP     *exprnc(ENODE **node);
  144. TYP     *commaop(ENODE **node);
  145. TYP     *expression(ENODE **node);
  146.  
  147.                              /* Floatexp.c */
  148.  
  149. long double floatexpr(void); /* PROTOTYPE */
  150. long double feprimary(void)   ;                                   /* STATIC */
  151. long double feunary(void);                                        /* STATIC */
  152. long double femultops(void);                                      /* STATIC */
  153. long double feaddops(void);                                       /* STATIC */
  154. long double floatexpr(void);
  155.  
  156.                                /* Func.c */
  157.  
  158. void funcini(void);
  159. void declfuncarg(int isint);
  160. void check_funcused(TABLE *oldlsym, TABLE *lsyms);
  161. void funcbody(SYM *sp);
  162. SYM     *makeint(char *name, TABLE *table);
  163. void addblocklist(SYM *sp);
  164. void block(void);
  165. void gather_labels(TABLE *oldlsym, TABLE *lsyms);
  166. SNODE *compoundblock(void);
  167.  
  168.                               /* Mangle.c */
  169.  
  170. void funcrefinsert(char *name, char *mangname, TYP *tp, TABLE *tbl);
  171. int fomatch(TYP *tp1, TYP *tp2);                                  /* STATIC */
  172. SYM *funcovermatch(char *name,TYP *tp);
  173. char *cpponearg(char *buf,TYP *tp);                               /* STATIC */
  174. char *cppargs(char *buf,SYM *sp);                                 /* STATIC */
  175. char * cppmangle(char *name, TYP *tp);
  176. char * putptr(char *buf, int *ptr, int **ptrs);
  177. char *unmang1(char *buf, char *name, int *ptr, int **ptrs);       /* STATIC */
  178. char * unmangcppfunc(char *buf, char *name);                      /* STATIC */
  179. void unmangle(char *buf, char *name);
  180.  
  181. /* Protogen Version 1.00 Saturday May 31, 1997  17:24:42 */
  182.  
  183.                               /* Getsym.c */
  184.  
  185. void initsym(void);
  186. void lineToCpp(void);
  187. void stripcomment (short *line);                                  /* STATIC */
  188. void striptrigraph(short *buf);
  189. int     getline(int listflag);
  190. int     getch(void);
  191. void     getid(void);
  192. int     getsch(void)        ;
  193. int     radix36(char c);
  194. void getbase(int b,char **ptr);
  195. void getfrac(char **ptr);
  196. void getexp(char **ptr);
  197. void getnum(void);
  198. int getsym2(void) ;
  199. void     getsym(void);
  200. int needpunc(enum e_sym p, int *skimlist);
  201. int needpuncexp(enum e_sym p, int *skimlist);
  202. void backup(int st);
  203.  
  204.                                /* Init.c */
  205.  
  206. void initini(void);
  207. void initrundown(void);
  208. long gen(SYM *sp);                                                /* STATIC */
  209. void cppinitinsert(ENODE *node);
  210. void doinit(SYM *sp);
  211. int     inittype(TYP *tp);
  212. int initarray(TYP *tp);
  213. int initstruct(TYP *tp);
  214. int makelabel(void);
  215. int makeref(int ispc, SYM *sp, long val);
  216. int makestorage(long val);
  217. int agflush(int size, long val);
  218. int agbits(int size, long value);
  219. int initfloat(void);
  220. int initlongdouble(void);
  221. int initdouble(void);
  222. int initchar(void);
  223. int initshort(void);
  224. int inituchar(void);
  225. int initushort(void);
  226. int initlong(void);
  227. int initulong(void);
  228. void getreflvalue(ENODE **node, TYP **tp,int pointer);
  229. int checkrefeval(ENODE *node);
  230. int refeval(ENODE *one, ENODE **two);
  231. int initref(TYP *tp);
  232. int initpointer(void);
  233. int initpointerfunc(void);
  234. void endinit(void);
  235.  
  236.                               /* Intexpr.c */
  237.  
  238. long ieprimary(TYP **tp)   ;                                      /* STATIC */
  239. long ieunary(TYP **tp);                                           /* STATIC */
  240. long iemultops(TYP **tp);                                         /* STATIC */
  241. long ieaddops(TYP **tp);                                          /* STATIC */
  242. long ieshiftops(TYP **tp);                                        /* STATIC */
  243. long ierelation(TYP **tp);                                        /* STATIC */
  244. long ieequalops(TYP **tp);                                        /* STATIC */
  245. long ieandop(TYP **tp);                                           /* STATIC */
  246. long iexorop(TYP **tp);                                           /* STATIC */
  247. long ieorop(TYP **tp);                                            /* STATIC */
  248. long ielandop(TYP **tp);                                          /* STATIC */
  249. long ielorop(TYP **tp);                                           /* STATIC */
  250. long iecondop(TYP **tp);                                          /* STATIC */
  251. long intexpr(TYP **tp);
  252.  
  253.                                /* List.c */
  254.  
  255. char * unmangledname(char *str);                                  /* STATIC */
  256. void put_sc(int scl);
  257. void put_ty(TYP *tp);
  258. void list_var(SYM *sp, int i);
  259. void list_table(TABLE *t,int j);
  260.  
  261.                               /* Memmgt.c */
  262.  
  263. void release_local(void); /* PROTOTYPE */
  264. void release_global(void); /* PROTOTYPE */
  265. void release_opt(void); /* PROTOTYPE */
  266. void release_oc(void); /* PROTOTYPE */
  267. void mem_summary(void); /* PROTOTYPE */
  268. void memini(void);
  269. char    *xalloc(int siz);
  270. char    *oalloc(int siz);
  271. char *ocalloc(int siz);
  272. void release_local(void );
  273. void release_global(void);
  274. void release_opt(void);
  275. void release_oc(void);
  276. void mem_summary(void);
  277.  
  278. /* Protogen Version 1.00 Saturday May 31, 1997  17:24:43 */
  279.  
  280.                              /* Optimize.c */
  281.  
  282. int maxinttype(ENODE *ep1, ENODE *ep2);
  283. int maxfloattype(ENODE *ep1, ENODE *ep2);
  284. int getmode(ENODE *ep1,ENODE *ep2);
  285. void dooper(ENODE ** node, int mode);
  286. long     pwrof2(int i);
  287. long     mod_mask(int i);
  288. void opt0(ENODE ** node);
  289. long     xfold2(ENODE * node);
  290. void fold_const2(ENODE ** node);
  291. void opt4(ENODE ** node);
  292.  
  293.                               /* Preproc.c */
  294.  
  295. void filemac(short *string); /* PROTOTYPE */
  296. void datemac(short *string); /* PROTOTYPE */
  297. void timemac(short *string); /* PROTOTYPE */
  298. void linemac(short *string); /* PROTOTYPE */
  299. void pushif(void); /* PROTOTYPE */
  300. void preprocini(void);
  301. int preprocess(void);
  302. int doerror(void);
  303. int dopragma(void);
  304. void dumpstartups(void);
  305. int doline(void);
  306. int doinclude(void);
  307. short *plitlate(short *string);
  308. void glbdefine(char *name, char*value);
  309. int dodefine(void);
  310. int doundef(void);
  311. int undef2(void);
  312. void getdefsym(void);
  313. int defid(short *name, short **p, char *q);
  314. int definsert(short *end, short *begin, short * text, int len, int replen);
  315. int defreplace(short *macro, int count, short **oldargs, short **newargs);
  316. void cnvt(short *out,char *in);
  317. void filemac(short *string);
  318. void datemac(short *string);
  319. void timemac(short *string);
  320. void linemac(short *string);
  321. void defmacroreplace(short *macro, short *name);
  322. void defcheck(short *line);
  323. void repdefines(short *lptr);                                     /* STATIC */
  324. void pushif(void);
  325. void popif(void);
  326. void ansieol(void);
  327. int doifdef (int flag);
  328. int doif(int flag);
  329. int doelif(void);
  330. int doelse(void);
  331. int doendif(void);
  332.  
  333.                              /* Searchkw.c */
  334.  
  335. void kwini(void) ;
  336. int searchkw(void);
  337.  
  338. /* Protogen Version 1.00 Saturday May 31, 1997  17:24:44 */
  339.  
  340.                                /* Stmt.c */
  341.  
  342. void stmtini(void);
  343. int scanassign(ENODE *node);
  344. TYP *doassign(ENODE **exp, int canerror, int *skm);
  345. SNODE    *whilestmt(void) ;
  346. SNODE    *dostmt(void) ;
  347. SNODE    *forstmt(void) ;
  348. SNODE    *ifstmt(void) ;
  349. SNODE    *casestmt(SNODE *lst) ;
  350. int     checkcases(SNODE *head) ;
  351. SNODE    *switchstmt(void) ;
  352. SNODE    *retstmt(void) ;
  353. SNODE    *breakstmt(void) ;
  354. SNODE    *contstmt(void) ;
  355. SNODE *_genwordstmt(void);
  356. SNODE    *exprstmt(void) ;
  357. SNODE *snp_line(void);
  358. void dodefaultinit(SYM *sp);
  359. void doautoinit(SYM *sym);
  360. SNODE    *compound(void) ;
  361. SNODE    *labelstmt(int fetchnext) ;
  362. SNODE    *gotostmt(void) ;
  363. SNODE *asm_statement(int shortfin); /* PROTOTYPE */
  364. SNODE    *statement(void) ;
  365. SNODE *cppblockedstatement(void);
  366.  
  367.                               /* Symbol.c */
  368.  
  369. void symini(void);
  370. unsigned int ComputeHash(char *string,int size);                  /* STATIC */
  371. HASHREC *AddHash(HASHREC *item,HASHREC **table,int size);
  372. HASHREC **LookupHash(char *key, HASHREC **table, int size);
  373. SYM     *search(char *na,TABLE *table);
  374. SYM     *gsearch(char *na);
  375. void insert(SYM *sp,TABLE *table);
  376.  
  377.                                /* Types.c */
  378.  
  379. int exactype(TYP *typ1, TYP *typ2);
  380. int checktype(TYP *typ1, TYP *typ2);
  381. int checktypeassign(TYP *typ1, TYP *typ2);
  382. TYP *unmang2(char *buf, TYP *tp, int *ptr, int **ptrs);           /* STATIC */
  383. char * typenum(char *buf, TYP *typ);